﻿using System;
using System.Text;
using HslCommunication.BasicFramework;

namespace HslCommunication.Core
{
	/// <summary>
	/// 数据转换类的基础，提供了一些基础的方法实现.<br />
	/// The basis of the data conversion class provides some basic method implementations.
	/// </summary>
	// Token: 0x02000122 RID: 290
	public class ByteTransformBase : IByteTransform
	{
		/// <summary>
		/// 实例化一个默认的对象<br />
		/// Instantiate a default object
		/// </summary>
		// Token: 0x060018BF RID: 6335 RVA: 0x0007DDD9 File Offset: 0x0007BFD9
		public ByteTransformBase()
		{
			this.DataFormat = DataFormat.DCBA;
		}

		/// <summary>
		/// 使用指定的数据解析来实例化对象<br />
		/// Instantiate the object using the specified data parsing
		/// </summary>
		/// <param name="dataFormat">数据规则</param>
		// Token: 0x060018C0 RID: 6336 RVA: 0x0007DDEB File Offset: 0x0007BFEB
		public ByteTransformBase(DataFormat dataFormat)
		{
			this.DataFormat = dataFormat;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransBool(System.Byte[],System.Int32)" />
		// Token: 0x060018C1 RID: 6337 RVA: 0x0007DDFD File Offset: 0x0007BFFD
		public virtual bool TransBool(byte[] buffer, int index)
		{
			return (buffer[index] & 1) == 1;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransBool(System.Byte[],System.Int32,System.Int32)" />
		// Token: 0x060018C2 RID: 6338 RVA: 0x0007DE08 File Offset: 0x0007C008
		public bool[] TransBool(byte[] buffer, int index, int length)
		{
			byte[] array = new byte[length];
			Array.Copy(buffer, index, array, 0, length);
			return SoftBasic.ByteToBoolArray(array, length * 8);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Byte[],System.Int32)" />
		// Token: 0x060018C3 RID: 6339 RVA: 0x0007DE35 File Offset: 0x0007C035
		public virtual byte TransByte(byte[] buffer, int index)
		{
			return buffer[index];
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Byte[],System.Int32,System.Int32)" />
		// Token: 0x060018C4 RID: 6340 RVA: 0x0007DE3C File Offset: 0x0007C03C
		public virtual byte[] TransByte(byte[] buffer, int index, int length)
		{
			byte[] array = new byte[length];
			Array.Copy(buffer, index, array, 0, length);
			return array;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransInt16(System.Byte[],System.Int32)" />
		// Token: 0x060018C5 RID: 6341 RVA: 0x0007DE61 File Offset: 0x0007C061
		public virtual short TransInt16(byte[] buffer, int index)
		{
			return BitConverter.ToInt16(buffer, index);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransInt16(System.Byte[],System.Int32,System.Int32)" />
		// Token: 0x060018C6 RID: 6342 RVA: 0x0007DE6C File Offset: 0x0007C06C
		public virtual short[] TransInt16(byte[] buffer, int index, int length)
		{
			short[] array = new short[length];
			for (int i = 0; i < length; i++)
			{
				array[i] = this.TransInt16(buffer, index + 2 * i);
			}
			return array;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransUInt16(System.Byte[],System.Int32)" />
		// Token: 0x060018C7 RID: 6343 RVA: 0x0007DEA7 File Offset: 0x0007C0A7
		public virtual ushort TransUInt16(byte[] buffer, int index)
		{
			return BitConverter.ToUInt16(buffer, index);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransUInt16(System.Byte[],System.Int32,System.Int32)" />
		// Token: 0x060018C8 RID: 6344 RVA: 0x0007DEB0 File Offset: 0x0007C0B0
		public virtual ushort[] TransUInt16(byte[] buffer, int index, int length)
		{
			ushort[] array = new ushort[length];
			for (int i = 0; i < length; i++)
			{
				array[i] = this.TransUInt16(buffer, index + 2 * i);
			}
			return array;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransInt32(System.Byte[],System.Int32)" />
		// Token: 0x060018C9 RID: 6345 RVA: 0x0007DEEB File Offset: 0x0007C0EB
		public virtual int TransInt32(byte[] buffer, int index)
		{
			return BitConverter.ToInt32(this.ByteTransDataFormat4(buffer, index), 0);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransInt32(System.Byte[],System.Int32,System.Int32)" />
		// Token: 0x060018CA RID: 6346 RVA: 0x0007DEFC File Offset: 0x0007C0FC
		public virtual int[] TransInt32(byte[] buffer, int index, int length)
		{
			int[] array = new int[length];
			for (int i = 0; i < length; i++)
			{
				array[i] = this.TransInt32(buffer, index + 4 * i);
			}
			return array;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransUInt32(System.Byte[],System.Int32)" />
		// Token: 0x060018CB RID: 6347 RVA: 0x0007DF37 File Offset: 0x0007C137
		public virtual uint TransUInt32(byte[] buffer, int index)
		{
			return BitConverter.ToUInt32(this.ByteTransDataFormat4(buffer, index), 0);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransUInt32(System.Byte[],System.Int32,System.Int32)" />
		// Token: 0x060018CC RID: 6348 RVA: 0x0007DF48 File Offset: 0x0007C148
		public virtual uint[] TransUInt32(byte[] buffer, int index, int length)
		{
			uint[] array = new uint[length];
			for (int i = 0; i < length; i++)
			{
				array[i] = this.TransUInt32(buffer, index + 4 * i);
			}
			return array;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransInt64(System.Byte[],System.Int32)" />
		// Token: 0x060018CD RID: 6349 RVA: 0x0007DF83 File Offset: 0x0007C183
		public virtual long TransInt64(byte[] buffer, int index)
		{
			return BitConverter.ToInt64(this.ByteTransDataFormat8(buffer, index), 0);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransInt64(System.Byte[],System.Int32,System.Int32)" />
		// Token: 0x060018CE RID: 6350 RVA: 0x0007DF94 File Offset: 0x0007C194
		public virtual long[] TransInt64(byte[] buffer, int index, int length)
		{
			long[] array = new long[length];
			for (int i = 0; i < length; i++)
			{
				array[i] = this.TransInt64(buffer, index + 8 * i);
			}
			return array;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransUInt64(System.Byte[],System.Int32)" />
		// Token: 0x060018CF RID: 6351 RVA: 0x0007DFCF File Offset: 0x0007C1CF
		public virtual ulong TransUInt64(byte[] buffer, int index)
		{
			return BitConverter.ToUInt64(this.ByteTransDataFormat8(buffer, index), 0);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransUInt64(System.Byte[],System.Int32,System.Int32)" />
		// Token: 0x060018D0 RID: 6352 RVA: 0x0007DFE0 File Offset: 0x0007C1E0
		public virtual ulong[] TransUInt64(byte[] buffer, int index, int length)
		{
			ulong[] array = new ulong[length];
			for (int i = 0; i < length; i++)
			{
				array[i] = this.TransUInt64(buffer, index + 8 * i);
			}
			return array;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransSingle(System.Byte[],System.Int32)" />
		// Token: 0x060018D1 RID: 6353 RVA: 0x0007E01B File Offset: 0x0007C21B
		public virtual float TransSingle(byte[] buffer, int index)
		{
			return BitConverter.ToSingle(this.ByteTransDataFormat4(buffer, index), 0);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransSingle(System.Byte[],System.Int32,System.Int32)" />
		// Token: 0x060018D2 RID: 6354 RVA: 0x0007E02C File Offset: 0x0007C22C
		public virtual float[] TransSingle(byte[] buffer, int index, int length)
		{
			float[] array = new float[length];
			for (int i = 0; i < length; i++)
			{
				array[i] = this.TransSingle(buffer, index + 4 * i);
			}
			return array;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransDouble(System.Byte[],System.Int32)" />
		// Token: 0x060018D3 RID: 6355 RVA: 0x0007E067 File Offset: 0x0007C267
		public virtual double TransDouble(byte[] buffer, int index)
		{
			return BitConverter.ToDouble(this.ByteTransDataFormat8(buffer, index), 0);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransDouble(System.Byte[],System.Int32,System.Int32)" />
		// Token: 0x060018D4 RID: 6356 RVA: 0x0007E078 File Offset: 0x0007C278
		public virtual double[] TransDouble(byte[] buffer, int index, int length)
		{
			double[] array = new double[length];
			for (int i = 0; i < length; i++)
			{
				array[i] = this.TransDouble(buffer, index + 8 * i);
			}
			return array;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransString(System.Byte[],System.Int32,System.Int32,System.Text.Encoding)" />
		// Token: 0x060018D5 RID: 6357 RVA: 0x0007E0B4 File Offset: 0x0007C2B4
		public virtual string TransString(byte[] buffer, int index, int length, Encoding encoding)
		{
			byte[] array = this.TransByte(buffer, index, length);
			bool isStringReverseByteWord = this.IsStringReverseByteWord;
			string @string;
			if (isStringReverseByteWord)
			{
				@string = encoding.GetString(SoftBasic.BytesReverseByWord(array));
			}
			else
			{
				@string = encoding.GetString(array);
			}
			return @string;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransString(System.Byte[],System.Text.Encoding)" />
		// Token: 0x060018D6 RID: 6358 RVA: 0x0007E0F2 File Offset: 0x0007C2F2
		public virtual string TransString(byte[] buffer, Encoding encoding)
		{
			return encoding.GetString(buffer);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Boolean)" />
		// Token: 0x060018D7 RID: 6359 RVA: 0x0007E0FB File Offset: 0x0007C2FB
		public virtual byte[] TransByte(bool value)
		{
			return this.TransByte(new bool[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Boolean[])" />
		// Token: 0x060018D8 RID: 6360 RVA: 0x0007E10D File Offset: 0x0007C30D
		public virtual byte[] TransByte(bool[] values)
		{
			return (values == null) ? null : SoftBasic.BoolArrayToByte(values);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Byte)" />
		// Token: 0x060018D9 RID: 6361 RVA: 0x0007E11B File Offset: 0x0007C31B
		public virtual byte[] TransByte(byte value)
		{
			return new byte[]
			{
				value
			};
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Int16)" />
		// Token: 0x060018DA RID: 6362 RVA: 0x0007E127 File Offset: 0x0007C327
		public virtual byte[] TransByte(short value)
		{
			return this.TransByte(new short[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Int16[])" />
		// Token: 0x060018DB RID: 6363 RVA: 0x0007E13C File Offset: 0x0007C33C
		public virtual byte[] TransByte(short[] values)
		{
			bool flag = values == null;
			byte[] result;
			if (flag)
			{
				result = null;
			}
			else
			{
				byte[] array = new byte[values.Length * 2];
				for (int i = 0; i < values.Length; i++)
				{
					BitConverter.GetBytes(values[i]).CopyTo(array, 2 * i);
				}
				result = array;
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.UInt16)" />
		// Token: 0x060018DC RID: 6364 RVA: 0x0007E18E File Offset: 0x0007C38E
		public virtual byte[] TransByte(ushort value)
		{
			return this.TransByte(new ushort[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.UInt16[])" />
		// Token: 0x060018DD RID: 6365 RVA: 0x0007E1A0 File Offset: 0x0007C3A0
		public virtual byte[] TransByte(ushort[] values)
		{
			bool flag = values == null;
			byte[] result;
			if (flag)
			{
				result = null;
			}
			else
			{
				byte[] array = new byte[values.Length * 2];
				for (int i = 0; i < values.Length; i++)
				{
					BitConverter.GetBytes(values[i]).CopyTo(array, 2 * i);
				}
				result = array;
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Int32)" />
		// Token: 0x060018DE RID: 6366 RVA: 0x0007E1F2 File Offset: 0x0007C3F2
		public virtual byte[] TransByte(int value)
		{
			return this.TransByte(new int[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Int32[])" />
		// Token: 0x060018DF RID: 6367 RVA: 0x0007E204 File Offset: 0x0007C404
		public virtual byte[] TransByte(int[] values)
		{
			bool flag = values == null;
			byte[] result;
			if (flag)
			{
				result = null;
			}
			else
			{
				byte[] array = new byte[values.Length * 4];
				for (int i = 0; i < values.Length; i++)
				{
					this.ByteTransDataFormat4(BitConverter.GetBytes(values[i]), 0).CopyTo(array, 4 * i);
				}
				result = array;
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.UInt32)" />
		// Token: 0x060018E0 RID: 6368 RVA: 0x0007E25D File Offset: 0x0007C45D
		public virtual byte[] TransByte(uint value)
		{
			return this.TransByte(new uint[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.UInt32[])" />
		// Token: 0x060018E1 RID: 6369 RVA: 0x0007E270 File Offset: 0x0007C470
		public virtual byte[] TransByte(uint[] values)
		{
			bool flag = values == null;
			byte[] result;
			if (flag)
			{
				result = null;
			}
			else
			{
				byte[] array = new byte[values.Length * 4];
				for (int i = 0; i < values.Length; i++)
				{
					this.ByteTransDataFormat4(BitConverter.GetBytes(values[i]), 0).CopyTo(array, 4 * i);
				}
				result = array;
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Int64)" />
		// Token: 0x060018E2 RID: 6370 RVA: 0x0007E2C9 File Offset: 0x0007C4C9
		public virtual byte[] TransByte(long value)
		{
			return this.TransByte(new long[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Int64[])" />
		// Token: 0x060018E3 RID: 6371 RVA: 0x0007E2DC File Offset: 0x0007C4DC
		public virtual byte[] TransByte(long[] values)
		{
			bool flag = values == null;
			byte[] result;
			if (flag)
			{
				result = null;
			}
			else
			{
				byte[] array = new byte[values.Length * 8];
				for (int i = 0; i < values.Length; i++)
				{
					this.ByteTransDataFormat8(BitConverter.GetBytes(values[i]), 0).CopyTo(array, 8 * i);
				}
				result = array;
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.UInt64)" />
		// Token: 0x060018E4 RID: 6372 RVA: 0x0007E335 File Offset: 0x0007C535
		public virtual byte[] TransByte(ulong value)
		{
			return this.TransByte(new ulong[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.UInt64[])" />
		// Token: 0x060018E5 RID: 6373 RVA: 0x0007E348 File Offset: 0x0007C548
		public virtual byte[] TransByte(ulong[] values)
		{
			bool flag = values == null;
			byte[] result;
			if (flag)
			{
				result = null;
			}
			else
			{
				byte[] array = new byte[values.Length * 8];
				for (int i = 0; i < values.Length; i++)
				{
					this.ByteTransDataFormat8(BitConverter.GetBytes(values[i]), 0).CopyTo(array, 8 * i);
				}
				result = array;
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Single)" />
		// Token: 0x060018E6 RID: 6374 RVA: 0x0007E3A1 File Offset: 0x0007C5A1
		public virtual byte[] TransByte(float value)
		{
			return this.TransByte(new float[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Single[])" />
		// Token: 0x060018E7 RID: 6375 RVA: 0x0007E3B4 File Offset: 0x0007C5B4
		public virtual byte[] TransByte(float[] values)
		{
			bool flag = values == null;
			byte[] result;
			if (flag)
			{
				result = null;
			}
			else
			{
				byte[] array = new byte[values.Length * 4];
				for (int i = 0; i < values.Length; i++)
				{
					this.ByteTransDataFormat4(BitConverter.GetBytes(values[i]), 0).CopyTo(array, 4 * i);
				}
				result = array;
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Double)" />
		// Token: 0x060018E8 RID: 6376 RVA: 0x0007E40D File Offset: 0x0007C60D
		public virtual byte[] TransByte(double value)
		{
			return this.TransByte(new double[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.Double[])" />
		// Token: 0x060018E9 RID: 6377 RVA: 0x0007E420 File Offset: 0x0007C620
		public virtual byte[] TransByte(double[] values)
		{
			bool flag = values == null;
			byte[] result;
			if (flag)
			{
				result = null;
			}
			else
			{
				byte[] array = new byte[values.Length * 8];
				for (int i = 0; i < values.Length; i++)
				{
					this.ByteTransDataFormat8(BitConverter.GetBytes(values[i]), 0).CopyTo(array, 8 * i);
				}
				result = array;
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.String,System.Text.Encoding)" />
		// Token: 0x060018EA RID: 6378 RVA: 0x0007E47C File Offset: 0x0007C67C
		public virtual byte[] TransByte(string value, Encoding encoding)
		{
			bool flag = value == null;
			byte[] result;
			if (flag)
			{
				result = null;
			}
			else
			{
				byte[] bytes = encoding.GetBytes(value);
				result = (this.IsStringReverseByteWord ? SoftBasic.BytesReverseByWord(bytes) : bytes);
			}
			return result;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.TransByte(System.String,System.Int32,System.Text.Encoding)" />
		// Token: 0x060018EB RID: 6379 RVA: 0x0007E4B4 File Offset: 0x0007C6B4
		public virtual byte[] TransByte(string value, int length, Encoding encoding)
		{
			bool flag = value == null;
			byte[] result;
			if (flag)
			{
				result = null;
			}
			else
			{
				byte[] bytes = encoding.GetBytes(value);
				result = (this.IsStringReverseByteWord ? SoftBasic.ArrayExpandToLength<byte>(SoftBasic.BytesReverseByWord(bytes), length) : SoftBasic.ArrayExpandToLength<byte>(bytes, length));
			}
			return result;
		}

		/// <summary>
		/// 反转多字节的数据信息
		/// </summary>
		/// <param name="value">数据字节</param>
		/// <param name="index">起始索引，默认值为0</param>
		/// <returns>实际字节信息</returns>
		// Token: 0x060018EC RID: 6380 RVA: 0x0007E4F8 File Offset: 0x0007C6F8
		protected byte[] ByteTransDataFormat4(byte[] value, int index = 0)
		{
			byte[] array = new byte[4];
			switch (this.DataFormat)
			{
			case DataFormat.ABCD:
				array[0] = value[index + 3];
				array[1] = value[index + 2];
				array[2] = value[index + 1];
				array[3] = value[index];
				break;
			case DataFormat.BADC:
				array[0] = value[index + 2];
				array[1] = value[index + 3];
				array[2] = value[index];
				array[3] = value[index + 1];
				break;
			case DataFormat.CDAB:
				array[0] = value[index + 1];
				array[1] = value[index];
				array[2] = value[index + 3];
				array[3] = value[index + 2];
				break;
			case DataFormat.DCBA:
				array[0] = value[index];
				array[1] = value[index + 1];
				array[2] = value[index + 2];
				array[3] = value[index + 3];
				break;
			}
			return array;
		}

		/// <summary>
		/// 反转多字节的数据信息
		/// </summary>
		/// <param name="value">数据字节</param>
		/// <param name="index">起始索引，默认值为0</param>
		/// <returns>实际字节信息</returns>
		// Token: 0x060018ED RID: 6381 RVA: 0x0007E5BC File Offset: 0x0007C7BC
		protected byte[] ByteTransDataFormat8(byte[] value, int index = 0)
		{
			byte[] array = new byte[8];
			switch (this.DataFormat)
			{
			case DataFormat.ABCD:
				array[0] = value[index + 7];
				array[1] = value[index + 6];
				array[2] = value[index + 5];
				array[3] = value[index + 4];
				array[4] = value[index + 3];
				array[5] = value[index + 2];
				array[6] = value[index + 1];
				array[7] = value[index];
				break;
			case DataFormat.BADC:
				array[0] = value[index + 6];
				array[1] = value[index + 7];
				array[2] = value[index + 4];
				array[3] = value[index + 5];
				array[4] = value[index + 2];
				array[5] = value[index + 3];
				array[6] = value[index];
				array[7] = value[index + 1];
				break;
			case DataFormat.CDAB:
				array[0] = value[index + 1];
				array[1] = value[index];
				array[2] = value[index + 3];
				array[3] = value[index + 2];
				array[4] = value[index + 5];
				array[5] = value[index + 4];
				array[6] = value[index + 7];
				array[7] = value[index + 6];
				break;
			case DataFormat.DCBA:
				array[0] = value[index];
				array[1] = value[index + 1];
				array[2] = value[index + 2];
				array[3] = value[index + 3];
				array[4] = value[index + 4];
				array[5] = value[index + 5];
				array[6] = value[index + 6];
				array[7] = value[index + 7];
				break;
			}
			return array;
		}

		/// <inheritdoc cref="P:HslCommunication.Core.IByteTransform.DataFormat" />
		// Token: 0x17000539 RID: 1337
		// (get) Token: 0x060018EE RID: 6382 RVA: 0x0007E704 File Offset: 0x0007C904
		// (set) Token: 0x060018EF RID: 6383 RVA: 0x0007E70C File Offset: 0x0007C90C
		public DataFormat DataFormat { get; set; }

		/// <inheritdoc cref="P:HslCommunication.Core.IByteTransform.IsStringReverseByteWord" />
		// Token: 0x1700053A RID: 1338
		// (get) Token: 0x060018F0 RID: 6384 RVA: 0x0007E715 File Offset: 0x0007C915
		// (set) Token: 0x060018F1 RID: 6385 RVA: 0x0007E71D File Offset: 0x0007C91D
		public bool IsStringReverseByteWord { get; set; }

		/// <inheritdoc cref="M:HslCommunication.Core.IByteTransform.CreateByDateFormat(HslCommunication.Core.DataFormat)" />
		// Token: 0x060018F2 RID: 6386 RVA: 0x0007E728 File Offset: 0x0007C928
		public virtual IByteTransform CreateByDateFormat(DataFormat dataFormat)
		{
			return this;
		}

		/// <inheritdoc />
		// Token: 0x060018F3 RID: 6387 RVA: 0x0007E73B File Offset: 0x0007C93B
		public override string ToString()
		{
			return string.Format("ByteTransformBase[{0}]", this.DataFormat);
		}
	}
}
